home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Applications / UIFlow 1.0.1 / UIFlow Source / VSet2.0 / temp / vg.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-12-16  |  15.0 KB  |  679 lines  |  [TEXT/????]
  1. /*****************************************************************************
  2. * 
  3. *              NCSA HDF Vset release 2.1
  4. *                    May 1991
  5. *
  6. * NCSA HDF Vset release 2.1 source code and documentation are in the public
  7. * domain.  Specifically, we give to the public domain all rights for future
  8. * licensing of the source code, all resale rights, and all publishing rights.
  9. * 
  10. * We ask, but do not require, that the following message be included in all
  11. * derived works:
  12. * 
  13. * Portions developed at the National Center for Supercomputing Applications at
  14. * the University of Illinois at Urbana-Champaign.
  15. * 
  16. * THE UNIVERSITY OF ILLINOIS GIVES NO WARRANTY, EXPRESSED OR IMPLIED, FOR THE
  17. * SOFTWARE AND/OR DOCUMENTATION PROVIDED, INCLUDING, WITHOUT LIMITATION,
  18. * WARRANTY OF MERCHANTABILITY AND WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE
  19. * 
  20. *****************************************************************************
  21. * Likkai Ng NCSA May 1991
  22. *
  23. * vg.c
  24. * Part of the HDF VSet interface
  25. * This file contains routine to handle VDATAs.
  26. *
  27. * Most routines return -1 (FAIL) on error. 
  28. * VSattach returns NULL on error.
  29. *
  30. * PRIVATE functions manipulate vsdir and are used only within this file.
  31. * PRIVATE data structures in here pertain to vdata in vsdir only.
  32. *
  33. **************************************************************************/
  34.  
  35. #include <ctype.h> 
  36. #include "vg.h"
  37.  
  38. PRIVATE int newref_count = -1; /* used by Vnewref only */
  39.  
  40. /* ------------------------------------------------------------------
  41. *    Vnewref
  42. *    utility routine. returns a unique reference number.
  43. *
  44. *    NOTE: should be modified to call DFnewref!!!
  45. *  currently looks once in vsdir and vgdir, and find the highest ref.
  46. *    also, the parameter f isn't used right now.
  47. *
  48. *    RETURNS a unique ref (+ve integer) ,
  49. *    RETURNS -1 if error
  50. *
  51. *  undocumented
  52. *
  53. */
  54.  
  55. int vnewref (f)            /*@@*/
  56.  
  57. DF  *f;
  58. {
  59. #if 0
  60.     int t;
  61.  
  62.  
  63.     if (f==NULL) return(FAIL);
  64.     if (newref_count == -1) {
  65.         for(t=1;t<65300;t++) {
  66.             if      ( -1 != vexistvg(f,t))   continue;
  67.             else if ( -1 != vexistvs(f,t))   continue;
  68.             else break;
  69.         }
  70.         newref_count = t;
  71.     }
  72.  
  73.     newref_count++;
  74.     if (newref_count > 65300) return(FAIL);
  75.  
  76.     return( newref_count - 1 );
  77. #endif
  78.  
  79. #if 1
  80.     return( DFnewref(f) );
  81. #endif
  82.  
  83. } /* vnewref */
  84.  
  85.  
  86. /* ------------------------------------------------------------------
  87. * VSelts
  88. * returns the number of elements in the VDATA vs 
  89. * returns -1  on error.
  90. *
  91. * undocumented
  92. * 28-MAR-91 Jason NG NCSA
  93. *
  94. */
  95.  
  96. PUBLIC int32 VSelts (vs)                       /*@-@*/
  97.  
  98. VDATA *vs;
  99. {
  100.     return( (vs->otag==VSDESCTAG) ?  vs->nvertices : -1);
  101.  
  102. } /* VSelts */
  103.  
  104.  
  105.  
  106. /* ------------------------------------------------------------------
  107. *    VSgetinterlace 
  108. *  returns the interlace (in the file) of the vdata vs.
  109. *  returns -1 on error.
  110. *
  111. *  undocumented
  112. *
  113. */
  114.  
  115. PUBLIC int VSgetinterlace (vs)              /*@-@*/
  116.  
  117. VDATA *vs;
  118. {
  119.     return( (vs==NULL) ? FAIL : vs->interlace );
  120.  
  121. } /* VSgetinterlace */
  122.  
  123.  
  124.  
  125. /* ------------------------------------------------------------------
  126. *    VSsetinterlace 
  127. *     sets the vdata's interlace to full or none.
  128. *    returns -1 on error.
  129. */
  130.  
  131. PUBLIC int VSsetinterlace (vs, interlace)      /*@-@*/
  132.  
  133. VDATA *vs;
  134. int interlace;
  135. {
  136.     if (vs==NULL)
  137.         return(FAIL);
  138.     if ( vs->access == 'r' ||            /* only for write-only files */
  139.     vs->nvertices > 0)             /*may not change interlace if data exists*/
  140.         return(FAIL);
  141.  
  142.     /* currently only 2 kinds allowed */
  143.  
  144.     if ( interlace==FULL_INTERLACE || 
  145.         interlace==NO_INTERLACE ) {
  146.         vs->interlace = interlace;
  147.         return(1); /* ok */
  148.     }
  149.     else 
  150.         return(FAIL);                            /* bad interlace type */
  151.  
  152. } /* VSsetinterlace */
  153.  
  154.  
  155. /* ------------------------------------------------------------------
  156. *    VSgetfields 
  157. *  returns the fieldnames in a vdata.
  158. *  RETURNS  -1 on error, else the no of fields in the vdata.
  159. *
  160. *    undocumented
  161. *
  162. */
  163.  
  164. PUBLIC int VSgetfields (vs,fields)        /*@-@*/
  165.  
  166. VDATA *vs;
  167. char  *fields;                            /* fieldnames are returned in this var */
  168. {
  169.     int i;
  170.     if (vs==NULL) return(FAIL);
  171.  
  172.     fields[0] = '\0';
  173.     for (i=0;i<vs->wlist.n;i++) { /* build the comma-separated string */
  174.         strcat(fields,vs->wlist.name[i]);
  175.         if ( i < vs->wlist.n - 1 )
  176.             strcat(fields,",");
  177.     }
  178.  
  179.     return(vs->wlist.n);
  180.  
  181. } /* VSgetfields */
  182.  
  183. /* ------------------------------------------------------------------
  184. *    VSfexist
  185. *     tests for existence of 1 or more fields in a vdata.
  186. *
  187. *    RETURNS -1 if flase, or error
  188. *    RETURNS 1 if true
  189. */
  190.  
  191. PUBLIC int VSfexist (vs, fields)          /*@-@*/
  192.  
  193. VDATA *vs;
  194. char    *fields;
  195. {
  196.     char           **av, *s;
  197.     int            ac,i,j,found;
  198.     VWRITELIST    *w;
  199.  
  200.     if (vs==NULL) return(FAIL);
  201.  
  202.     /* call scanattrs to parse the string */
  203.  
  204.     if (scanattrs(fields,&ac,&av) < 0) return(FAIL); /* bad attrs string */
  205.     if (ac<1) return(FAIL);                                 /* no attrs */
  206.  
  207.     /* now check in vs's field table */
  208.  
  209.     w = &vs->wlist;
  210.     for (i=0;i<ac;i++) {
  211.         for (found=0,s=av[i],j=0;j<w->n;j++) {
  212.             if ( matchnocase(s,w->name[j]) ) {
  213.                 found=1;
  214.                 break;
  215.             }
  216.         }
  217.         if (!found) return(FAIL);
  218.     }
  219.  
  220.     return(1);
  221.  
  222. } /* VSfexist */
  223.  
  224.  
  225. /* ================================================================== */
  226. /*
  227. *    VSsizeof - computes the byte size of the field(s) of a vdata.
  228. *             - Note that the size is the actual size for the local machine.
  229. *
  230. *                - RETURNS -1 on error, else the field(s) size (+ve integer).
  231. */
  232.  
  233. PUBLIC int VSsizeof (vs, fields)           /*@-@*/
  234.  
  235. VDATA *vs;
  236. char  *fields;
  237. {
  238.     int     totalsize, ac, i,j,found;
  239.     char   **av;
  240.  
  241.     if (vs==NULL)                              return(FAIL);
  242.  
  243.     if (scanattrs(fields,&ac,&av) < 0) return(FAIL);     /* bad attrs string */
  244.     if (ac<1)                                  return(FAIL);     /* no attrs */
  245.  
  246.     if (vjv) { 
  247.         sprintf(sjs,"#VSsizeof: fields are [%s]\n",fields);
  248.         zj; 
  249.     }
  250.  
  251.     totalsize=0;
  252.     for (i=0;i<ac;i++) {
  253.         for (found=0,j=0;j<vs->wlist.n;j++)
  254.             if (!strcmp(av[i], vs->wlist.name[j])) {  /* check fields in vs */
  255.                 totalsize += vs->wlist.esize[j];
  256.                 found=1;
  257.                 break;
  258.             }
  259.  
  260.         if (!found) {
  261.             sprintf(sjs,"@VSsizeof:[%s] not in vs\n",av[i]);
  262.             zj;
  263.             return(FAIL);
  264.         }
  265.     }
  266.  
  267.     return(totalsize);
  268.  
  269. } /* VSsizeof */
  270.  
  271. /* ================================================================== */
  272.  
  273. /* matchnocase -  (PRIVATE) compares 2 strings, ignoring case 
  274. *                   returns 1 if match, else 0
  275. */
  276.  
  277. PRIVATE int matchnocase (strx,stry)     /*@@*/
  278.  
  279. char *strx,*stry;
  280. {
  281.     int     i,nx,ny,tx,ty;
  282.     char     *sx, *sy;
  283.  
  284.     nx = strlen(strx);
  285.     ny = strlen(stry);
  286.     if ( nx != ny) return(0);  /* different lengths */
  287.  
  288.     for (sx=strx, sy=stry, i=0;i<nx;i++,sx++,sy++) {
  289.         tx= *sx; 
  290.         ty= *sy;
  291.         if (islower(tx)) tx=toupper(tx);
  292.         if (islower(ty)) ty=toupper(ty);
  293.         if (tx != ty)       return(0);
  294.     }
  295.  
  296.     return(1);
  297.  
  298. } /* matchnocase */
  299.  
  300.  
  301. /* ================================================================== */
  302.  
  303. /*
  304. *    VSdump - prints contents of a vdata (for debugging) 
  305. *                no return codes.
  306. */
  307.  
  308. void VSdump (vs)                           /*@@*/
  309.  
  310. VDATA *vs;
  311. {
  312.     VWRITELIST    *w;
  313.     int             i;
  314.  
  315.     if (vs==NULL) {
  316.         sprintf(sjs,"@VSdump: vs is null\n");
  317.         zj;
  318.         return;
  319.     }
  320.  
  321.     sprintf(sjs,"@tag=%d ref=%d i=%d ",vs->otag, vs->oref,vs->interlace);
  322.     zj;
  323.     sprintf(sjs,"@nv=%d\n ",vs->nvertices);
  324.     zj;
  325.  
  326.     w = (VWRITELIST*) &vs->wlist;
  327.     sprintf(sjs,"@vsize(HDF)=%d fields=%d [%s]\n",w->ivsize,w->n,vs->vsname);
  328.     zj;
  329.  
  330.     for (i=0;i<w->n;i++)
  331.     { 
  332.         sprintf(sjs,"@<%s>      type:%d esize=%d isize=%d off=%d\n",
  333.             w->name[i], w->type[i], w->esize[i],w->isize[i],w->off[i]);
  334.         zj;
  335.     }
  336.  
  337.     sprintf(sjs,"\n");
  338.     zj;
  339.  
  340. } /* VSdump */
  341.  
  342.  
  343. /* ======================================================= */
  344. /*
  345. *    VSsetname - give a name to a vdata.
  346. *              - NO RETURN VALUES
  347. *              - truncates to max length of VSNAMELENMAX
  348. *      
  349. */
  350.  
  351. PUBLIC void VSsetname (vs, vsname)           /*@-@*/
  352.  
  353. VDATA *vs;
  354. char    *vsname;
  355.  
  356. {
  357.     if (vs == NULL) return;
  358.     if ( strlen(vsname) > VSNAMELENMAX) {
  359.         strncpy(vs->vsname, vsname,VSNAMELENMAX);
  360.         vs->vsname[VSNAMELENMAX]='\0';
  361.     }
  362.     else 
  363.         strcpy(vs->vsname, vsname);
  364.     vs->marked = 1;
  365.     return;
  366.  
  367. } /* VSsetname */
  368.  
  369. /* ======================================================= */
  370. /*
  371. *    VSsetclass- assigns a class name to a vdata.
  372. *              - NO RETURN VALUES
  373. *              - truncates to max length of VSNAMELENMAX
  374. *      
  375. */
  376.  
  377. PUBLIC void VSsetclass (vs, vsclass)           /*@-@*/
  378.  
  379. VDATA *vs;
  380. char    *vsclass;
  381.  
  382. {
  383.     if (vs == NULL) return;
  384.     if ( strlen(vsclass) > VSNAMELENMAX) {
  385.         strncpy(vs->vsclass, vsclass,VSNAMELENMAX);
  386.         vs->vsclass[VSNAMELENMAX]='\0';
  387.     }
  388.     else 
  389.         strcpy(vs->vsclass, vsclass);
  390.     vs->marked = 1;
  391.     return;
  392.  
  393. } /* VSsetclass*/
  394.  
  395. /* ======================================================= */
  396.  
  397. /*
  398. *    VSgetname - gets the vdata's name.
  399. *                 - NO RETURN VALUES
  400. */
  401.  
  402. PUBLIC void VSgetname (vs, vsname)           /*@-@*/
  403.  
  404. VDATA *vs;
  405. char    *vsname;
  406. {
  407.     if (vs != NULL) strcpy(vsname, vs->vsname);
  408.     return;
  409.  
  410. } /* VSgetname */
  411.  
  412. /* ======================================================= */
  413.  
  414. /*
  415. *    VSgetclass - gets the vdata's class name.
  416. *                 - NO RETURN VALUES
  417. */
  418.  
  419. PUBLIC void VSgetclass (vs, vsclass)           /*@-@*/
  420.  
  421. VDATA *vs;
  422. char    *vsclass;
  423. {
  424.     if (vs != NULL) strcpy(vsclass, vs->vsclass);
  425.     return;
  426.  
  427. } /* VSgetclass */
  428.  
  429.  
  430. /* ================================================================== */
  431. /*
  432. *    VSinquire - gets info about a vdata vs:
  433. *
  434. *                  nvertices:     no of vertices in it.
  435. *                  interlace:     its interlcae
  436. *                  fields :         a comma separated string listing the field(s). 
  437. *                                    (eg "PX,PY")
  438. *                  eltsize:        size of element (all field(s)) on local machine.
  439. *                  vsname:         vdata's name, if any.
  440. *
  441. *    RETURNS -1 if error
  442. *    RETURNS 1 if ok
  443. *
  444. */
  445.  
  446.  
  447. PUBLIC int VSinquire (vs, nelt, interlace, fields, eltsize, vsname)   /*@-@*/
  448.  
  449. VDATA     *vs;
  450. char      *fields, *vsname;
  451. int         *nelt, *interlace, *eltsize;
  452.  
  453. {
  454.     if (vs==NULL) return(FAIL);
  455.     VSgetfields (vs,fields);
  456.  
  457.     *nelt       = vs->nvertices;
  458.     *interlace  = vs->interlace;
  459.     *eltsize    =  VSsizeof (vs,fields);
  460.     strcpy(vsname,vs->vsname);
  461.  
  462.     return(1); /* ok */
  463.  
  464.  
  465. } /* VSinquire */
  466.  
  467. /* ================================================================== */
  468. /*
  469. * VSlone - returns an array of refs of all lone vdatas in the file.
  470. *           - returns -1 if error
  471. *          - otherwise returns the total number of lone vdatas in the file 
  472. *
  473. *            If idarray is too small, routine will only fill idarray with up
  474. *             to asize worth of refs.
  475. *
  476. *            INPUT idarray: user supplies  an int array.
  477. *           INPUT asize: integer specifying how many ints in idarray[];
  478. *            INPUT f: HDF file pointer.
  479. *
  480. */
  481.  
  482. PUBLIC int VSlone(f, idarray, asize) 
  483.  
  484. DF * f;
  485. int idarray[];             /* array to contain the refs */
  486. int asize;            /* input: size of idarray */
  487. {
  488. int      * lonevdata; /* local working area: stores flags of vdatas */
  489. int         i,vgid, vsid, vstag;
  490. VGROUP     * vg;
  491. int         dum;
  492. int         nlone; /* total number of lone vdatas */
  493.  
  494.  
  495. /* -- allocate space for vdata refs, init to zeroes -- */
  496. if (NULL == (lonevdata = (int*) DFIgetspace( 65000 * sizeof(int)))) 
  497.    RTNEG ("VSlone: space too low. VSlone not executed\n");
  498. for(i=0;i<65000;i++) lonevdata[i] = 0;
  499.  
  500. /* -- look for all vdatas in the file, and flag (1) each -- */
  501. vsid = -1;
  502. dum=0;
  503. while(1) {
  504.     if ( -1 == (vsid = VSgetid (f, vsid))) break; /* no more vdatas */
  505.     lonevdata[vsid ] = 1;
  506.     }
  507.  
  508. /* -- Look through all vgs, searching for vdatas -- */
  509. /* -- increment its index in lonevdata if found -- */
  510. dum=0;
  511. vgid = -1;
  512. while(1) {
  513.     if ( -1 == (vgid = Vgetid (f, vgid))) break; /* no more vgroups */
  514.     vg = (VGROUP*) Vattach(f,vgid,"r");
  515.     for (i=0; i< Vntagrefs(vg); i++) {
  516.         Vgettagref (vg, i, &vstag, &vsid);
  517.         if (vstag==VSDESCTAG) 
  518.             { lonevdata[vsid]++; dum++;  }
  519.         }
  520.     Vdetach(vg);
  521.     }
  522.  
  523. /* -- check in lonevdata: it's a lone vdata if its flag is still 1 -- */
  524. nlone = 0;
  525. for(i=0;i<65000;i++) {
  526.     if (1 == lonevdata[i]) {
  527.          if (nlone < asize) { /* insert into idarray up till asize */
  528.             idarray[nlone] = i;
  529.             }
  530.         nlone ++;
  531.         }
  532.    }
  533. DFIfreespace(lonevdata);
  534.  
  535. return(nlone); /* return the TOTAL # of lone vdatas */
  536.  
  537. } /* VSlone */
  538.  
  539. /* ================================================================== */
  540. /*
  541. * Vlone  - returns an array of refs of all lone vgroups in the file.
  542. *           - returns -1 if error
  543. *          - otherwise returns the total number of lone vgroups in the file 
  544. *
  545. *            If idarray is too small, routine will only fill idarray with up
  546. *             to asize worth of refs.
  547. *
  548. *            INPUT idarray: user supplies  an int array.
  549. *           INPUT asize: integer specifying how many ints in idarray[];
  550. *            INPUT f: HDF file pointer.
  551. *
  552. */
  553.  
  554. PUBLIC int Vlone(f, idarray, asize) 
  555.  
  556. DF * f;
  557. int idarray[];             /* array to contain the refs */
  558. int asize;            /* input: size of idarray */
  559. {
  560. int         * lonevg; /* local working area: stores flags of vgroups */
  561. int        i;
  562. int         vgid, vstag, id;
  563. VGROUP     * vg;
  564. int         dum;
  565. int         nlone; /* total number of lone vgroups */
  566.  
  567.  
  568. /* -- allocate space for vgroup refs, init to zeroes -- */
  569. if (NULL == (lonevg = (int*) DFIgetspace( 65000 * sizeof(int)))) 
  570.    RTNEG ("Vlone: space too low. Vlone not executed\n");
  571. for(i=0;i<65000;i++) lonevg[i] = 0;
  572.  
  573. /* -- look for all vgroups in the file, and flag (1) each -- */
  574. id = -1;
  575. dum=0;
  576. while(1) {
  577.     if ( -1 == (id = Vgetid (f, id))) break; /* no more vgroups */
  578.     lonevg[ id ] = 1;
  579.     }
  580.  
  581. /* -- Look through all vgs, searching for vgroups -- */
  582. /* -- increment its index in lonevg if found -- */
  583. dum=0;
  584. vgid = -1;
  585. while(1) {
  586.     if ( -1 == (vgid = Vgetid (f, vgid))) break; /* no more vgroups */
  587.    printf("Vlone: vgid=%d..attach",vgid);
  588.     vg = (VGROUP*) Vattach(f,vgid,"r");
  589.    printf("..attach done\n");
  590.     id = -1;
  591.     for (i=0; i< Vntagrefs(vg); i++) {
  592.         Vgettagref (vg, i, &vstag, &id);
  593.         if (vstag==VGDESCTAG) { lonevg[id]++; dum++;  }
  594.         }
  595.     Vdetach(vg);
  596.     }
  597.  
  598. /* -- check in lonevg: it's a lone vgroup if its flag is still 1 -- */
  599. nlone = 0;
  600. for(i=0;i<65000;i++) {
  601.     if (1 == lonevg[i]) {
  602.          if (nlone < asize) { /* insert into idarray up till asize */
  603.             idarray[nlone] = i;
  604.             }
  605.         nlone ++;
  606.         }
  607.    }
  608. DFIfreespace(lonevg);
  609.  
  610. return(nlone); /* return the TOTAL # of lone vgroups */
  611.  
  612. } /* Vlone */
  613.  
  614.  
  615. /* ================================================================== */
  616. /* new jan 3 1991 */
  617. /* looks in the file and returns the ref of the vgroup with name vgname */
  618. /* 
  619. * returns -1 if not found, or error.
  620. * otherwise, returns the vgroup's ref (a +ve integer).
  621. */
  622.  
  623. int Vfind (f, vgname)
  624. DF * f;
  625. char * vgname;
  626. {
  627.   int vgid = -1;
  628.   VGROUP* vg;
  629.   char name[512];
  630.  
  631.     while ( -1 != (vgid=Vgetid(f, vgid)) ) {
  632.         vg = (VGROUP*) Vattach(f,vgid,"r");
  633.         if (vg==NULL) return(-1);             /* error */
  634.         Vgetname(vg, name);
  635.         Vdetach (vg);
  636.         if (!strcmp(vgname,name)) return (vg->oref);  /* found the vgroup */
  637.       }
  638.       return(-1); /* not found */
  639.  
  640. } /* Vfind */
  641.  
  642. /* ================================================================== */
  643. /* new jan 3 1991 */
  644. /* looks in the file and returns the ref of the vdata with name vsname */
  645. /* 
  646. * returns -1 if not found, or error.
  647. * otherwise, returns the vdata's ref (a +ve integer).
  648. */
  649.  
  650. int VSfind (f, vsname)
  651. DF * f;
  652. char * vsname;
  653. {
  654.   int vsid = -1;
  655.   VDATA * vs;
  656.   char name[512];
  657.  
  658.     while ( -1 != (vsid=VSgetid(f, vsid)) ) {
  659.         vs = (VDATA*) VSattach(f,vsid,"r");
  660.         if (vs==NULL) return(-1);             /* error */
  661.         VSgetname(vs, name);
  662.         VSdetach (vs);
  663.         if (!strcmp(vsname, name)) return (vs->oref);  /* found the vdata */
  664.       }
  665.       return(-1); /* not found */
  666.  
  667. } /* VSfind */
  668.  
  669. /* ================================================================== */
  670.  
  671. /*
  672. * Vsetzap: Useless now. Maintained for back compatibility.
  673. */
  674.  
  675. Vsetzap() {
  676.     if (vjv) { sprintf(sjs,"Vsetzap: defunct\n"); zj; }
  677. }
  678. /* ================================================================== */
  679.